🔷 What is a Wrapper Class?
A Wrapper class is a class whose object wraps a primitive data type.
Java provides these classes in the java.lang package to convert primitive types into
objects.
Key Difference: Primitives are not objects, stored on stack, faster; Wrappers are objects, stored on heap, can be null, have methods.
🔍 Why Wrapper Classes are Needed?
Key Reasons:
- Collections API: Like
ArrayList,HashMapcan only store objects (not primitives) - Utilities: Wrapper classes have methods like
parseInt(),compare(),valueOf() - Autoboxing/Unboxing: Java automatically converts between primitives and wrappers
- Can be null: Useful when working with databases where a value may be unknown
- Generic Support: Generics in Java (like
<T>) do not support primitives, only objects
🔁 Autoboxing and Unboxing
Autoboxing = primitive ➡️ object (like putting primitive in a box)
Unboxing = object ➡️ primitive (opening the box)
public class AutoBoxingExample {
public static void main(String[] args) {
int a = 10;
// Autoboxing
Integer obj = a;
// Unboxing
int b = obj;
System.out.println("Object: " + obj);
System.out.println("Primitive: " + b);
}
}
Note: Introduced in Java 5 for seamless conversion. But beware of NullPointerException during unboxing if wrapper is null.
💼 Real-Life Example
Let's say you want to store user ages in a list:
ArrayList<Integer> ages = new ArrayList<>();
ages.add(25); // Autoboxing happens here: int ➝ Integer
ages.add(30);
int sum = ages.get(0) + ages.get(1); // Unboxing: Integer ➝ int
System.out.println("Sum of ages: " + sum);
Analogy: Primitives are like raw ingredients; wrappers are packaged versions for storage in a fridge (collections).
🛠️ Useful Wrapper Class Methods
public class WrapperMethods {
public static void main(String[] args) {
String number = "100";
int value = Integer.parseInt(number); // Convert string to int
System.out.println("Parsed value: " + value);
String text = Integer.toString(1234); // Convert int to string
System.out.println("String value: " + text);
boolean result = Boolean.parseBoolean("true");
System.out.println("Boolean value: " + result);
char ch = 'A';
System.out.println("Is Digit: " + Character.isDigit(ch));
System.out.println("Is Uppercase: " + Character.isUpperCase(ch));
}
}
Key Point: All wrappers are immutable – once created, value can't change.
🤔 Interactive Self-Quiz for Wrapper Classes
Test your understanding with these expandable questions. Click to reveal answers.
What is the wrapper for int?
Integer
What happens in autoboxing?
Primitive to wrapper object conversion automatically.
Can wrappers be null?
Yes, unlike primitives.
Why use parseInt?
To convert String to int.
📌 Interview Point of View (Wrapper Class)
| 🔹 Question | 💬 Expected Answer |
|---|---|
| What is a wrapper class? | A class that converts a primitive type into an object. |
| Why are wrapper classes needed? | For collections, generics, null handling, utilities. |
| Difference between Integer and int? | int is primitive, Integer is a class (object). |
| What is autoboxing/unboxing? | Auto conversion between primitive and wrapper. |
Can you store int in ArrayList? |
Not directly — it uses Integer via autoboxing. |
| Are wrapper classes immutable? | Yes, their values cannot be changed after creation. |
| What is the risk with unboxing? | NullPointerException if wrapper is null. |
| Difference between valueOf() and parseInt()? | valueOf() returns Integer, parseInt() returns int. |
📘 Generics in Java
🔹 What is Generics?
Generics allows writing code that works with different data types while providing type safety.
Introduced in: Java 5
🔹 Why Use Generics?
- ✅ Type safety
- ✅ Reusability
- ✅ Compile-time checking
- ✅ No need for type casting
🔹 Generic Class Example
class Box<T> {
T value;
void setValue(T val) { value = val; }
T getValue() { return value; }
}
🔹 Using Generic Class
Box<String> s = new Box<>();
s.setValue("Hi");
System.out.println(s.getValue());
🔹 Generic Method
public <T> void print(T[] arr) {
for (T t : arr)
System.out.println(t);
}
🔹 Bounded Type
class Demo<T extends Number> {
void show(T n) {
System.out.println(n.doubleValue());
}
}
🔹 Wildcards
<?>– unknown type<? extends Number>– any subclass of Number<? super Integer>– any superclass of Integer
Analogy: Wildcards are like jokers in cards – flexible but with rules.
✅ Summary
- Generic = Type-safe reusable code
- Used in collections, utilities, containers
- Makes code more readable and safer
🤔 Interactive Self-Quiz for Generics
Test your understanding with these expandable questions. Click to reveal answers.
What problem do generics solve?
Type safety in collections without casting.
What is ?
Upper bounded wildcard – subtypes of T.
Can generics use primitives?
No, only reference types; use wrappers for primitives.
📌 Interview Point of View (Generics)
| 🔹 Question | 💬 Expected Answer |
|---|---|
| What are generics in Java? | Parameterized types for type-safe code. |
| Benefits of generics? | Type safety, no casting, compile-time checks. |
| What is erasure? | Generics info removed at compile-time for backward compatibility. |
| Difference between List and List | List is raw wildcard, can't add; List |
| What are bounded generics? | Restrict types, e.g., |
| PECS rule? | Producer Extends, Consumer Super for wildcards. |
❓ What is a Fully Object-Oriented Language?
A fully object-oriented language is one where:
- Everything is an object
- All operations are done via method calls on objects
- There are no primitive types, functions, or statics outside objects
Smalltalk, Ruby, Scala
❌ Why Java is Not 100% Object-Oriented?
| Reason | Explanation |
|---|---|
| Primitive Types | Java has int, float, char, etc., which are not
objects. (For performance reasons) |
| Static Methods/Variables | Methods like Math.sqrt() don't need objects. |
| Limited Operator Overloading | Custom operator overloading is not allowed. |
| Top-Level Code Outside Objects | Static context used before object creation (e.g., main method). |
Why Primitives? Faster execution, less memory – primitives on stack, objects on heap.
🔄 Comparison: Java vs Pure OOP
🟡 Java (Hybrid)
- Has primitive types
- Static methods exist
- Performance optimized
- Easier to learn
🟢 Pure OOP (Smalltalk)
- Everything is an object
- All operations via messages
- Consistent design
- More complex
🤔 Interactive Self-Quiz for OOP Concepts
Test your understanding with these expandable questions. Click to reveal answers.
Why primitives in Java?
For better performance and memory efficiency.
Is static method OOP?
No, as it doesn't require an object instance.
Example of pure OOP language?
Smalltalk or Ruby.
📌 Interview Point of View (Object-Oriented)
| 🔹 Question | 💬 Expected Answer |
|---|---|
| Is Java fully object-oriented? | No, because it uses primitive types and static members. |
| Why does Java have primitives? | For performance – primitives are faster and use less memory. |
| What makes Java object-oriented? | Class-based, supports encapsulation, inheritance, polymorphism, and abstraction. |
| What breaks pure OOP in Java? | int, boolean, static methods/fields, etc. |
| Can Java be considered OOP? | Yes, it's OOP but not purely due to non-object elements. |
| Advantages of not being pure OOP? | Better performance with primitives, easier static utilities. |
🧾 Final Summary
✅ Wrapper Class Summary
- Wraps primitives into objects
- Needed for collections, generics, and utility methods
- Supports autoboxing and unboxing
- Used in real-world for converting data, storing values, and performing object-based operations
✅ Java Is Not Fully OOP Because:
- Uses primitive types (
int,char, etc.) - Allows static methods/variables
- Not everything is an object (unlike Ruby or Smalltalk)
🧠 Quick Revision for Interviews
- Wrapper class is used to convert primitives to objects
- Java has 8 wrapper classes:
Integer,Double, etc. - Autoboxing = primitive to object | Unboxing = object to primitive
- Java is not fully object-oriented due to use of primitives and statics
- Generics: Type-safe, reusable code with <T>